listview: Set accessible roles

Use the LIST and LIST_ITEM roles for GtkListView
and its children. Use the GRID and GRID_CELL roles
for GtkGridView and its children.

Document accessible roles for stacks and notebooks

This was forgotten when I implemented the Tabs pattern.

flowbox: Set accessible roles

Use the GRID and GRID_CELL roles for GtkFlowBox
and GtkFlowBoxChild.

listbox: Set accessible roles

Use the LIST and LIST_ITEM roles for GtkListBox
and GtkListBoxRow.

atspi: Add some docs

Add a comment that explains a few of the more subtle
points of the Atspi context tree contstruction.

atspi: Implement Selection for notebook tabs

This is a bit different from the way things were done
in GTK 3 - we follow what was done for GtkStackSwitcher,
and make the tab bar carry the GTK_ACCESSIBLE_TAB_LIST
role, and implement Selection there.

notebook: Set accessible roles and properties

Set up the necessary roles, relations and properties
for the tab patterns. This parallels what we have done
for GtkStackSwitcher, and implements the Tabs pattern
as described in the ARIA authoring guidelines.

atspi: Don't crash on unnamed stack pages

GtkNotebook creates unnamed stack pages, and we should
not crash when that happens.

gizmo: Add a way to set accessible role

This will be used for some of the gizmo used
inside GtkNotebook.

atspi: Implement Selection for GtkStackSwitcher

stackswitcher: Set up relations and states

Set up a CONTROLS relation between each tab button
and its page, and update the SELECTED property of
the buttons to match their active state.

stackswitcher: Use the tablist and tab roles

Set the tablist role on the stackswitcher itself, and
the tab role on the buttons. This is another step towards
implementing the tabs pattern for GtkStack.

accessible: Avoid realizing the context prematurely

platform change is called from gtk_widget_set_focusable
which is likely to be called early on in init(). We don't
want to create an AT context that early if we can help
it, e.g. since it makes it impossible to override the
accessible-role with a construct property.

stack: Turn pages into accessibles

This requires some cleanup to remove assumptions
about accessibles being widgets in the backend,
and some code to navigate the tree with these
extra objects in between widgets.

The accessibles for stack pages have the role
GTK_ACCESSIBLE_ROLE_TAB_PANEL. This is the first
step towards implementing the tabs patterns
as described in the aria authoring guidelines
for GtkStack.

docs: Fix a copy-paste error

Cosmetics

Fix a few copy-paste errors.

Cosmetics

Avoid typo-prone repetition of the full interface names.
We have them in the introspection data already.

dropdown: Use the combox accessible role

Its really just a combobox with another name.

combobox: Use the combobox accessible role

Makes sense.

atspi: Implement Selection for GtkFlowBox

This is a copy of the listbox implementation.

flowbox: Update accessible state for children

Set the SELECTED state to reflect whether the selected
is selected, unselected, or unselectable. This is
enough to make selection changes appear in Accerciser.

While we are at it, also set the multi-selectable
property for the flowbox itself.

atspi: Implement Selection for GtkComboBox

This doesn't really work in Accerciser. But then,
neither does the GTK 3 implementation from which
this is copied.

Remove excessively spammy debug messages

Non need to announce the same things for every context
we create, and the path is not really that interesting.
without knowing what it belongs to. I would suggest to
make it visible in the inspector instead, so you can
look it up for the widgets you are interested in.

Fix compiler warnings

Remove some unused code

atspi: Fix a variant parser oversight

When you pass a variant, the format needs an @.
GVariant is not your friend.

atspi: Implement Selection for listbox

Implement the selection interface for GtkListBox.

This also includes a convenience api for context
addresses: gtk_at_spi_context_to_ref.

listbox: Update accessible state for rows

Set the SELECTED state to reflect whether the row
is selected, unselected, or unselectable. This is
enough to make selection changes appear in Accerciser.

While we are at it, also set the multi-selectable
property for the listbox itself.

Fix the build

I forgot a few casts in a02c50e72fb6f5b.

atspi: Fix up the role for password entries

We use to set the the 'password text' role for entries with
visibility = FALSE. Nowadays, we have a separate class for
password entries, so fix up the role mapping based on that.

atspi: Make text change notification work

Make text change notification work for editables, by connecting
to the ::insert-text and ::delete-text signals on the wrapped
GtkText widget, and for GtkTextView by connecting to the
corresponding GtkTextBuffer signals.

This code is more or less directly copied from GtkTextViewAccessible
and GtkEntryAccessible in GTK 3.

text: Make editable signals work again

Since the big editable reorg, GtkText was not emitting
::insert-text and ::delete-text, as is expected of
editables. We want to use those signals for a11y
change notification, so make them work again.

atspi: Set placeholder-text attribute

This is how GTK3 passes placeholder-text to orca,
and it works - orca reads it.

atspi: Implement EditableText interface for the entry wrappers

Drop the EditableText implementation for GtkText,
and implement it for all the wrapper widgets instead.

accessible: Add some docs

Explain briefly how a11y works for entry wrappers
(since I won't remember a few months from now).

atspi: Implement Text interface for the entry wrappers

Drop the Text implementation for GtkText, and implement
it for all the wrapper widgets instead.

spinbutton: Implement GtkAccessible

This copies what was done for GtkEntry: get
the focused state from the GtkText within.

We also add a private getter for the text widget,
which was missing here.

passwordentry: Implement GtkAccessible

This copies what was done for GtkEntry: get
the focused state from the GtkText within.

searchentry: Implement GtkAccessible

This copies what was done for GtkEntry: get
the focused state from the GtkText within.

entry: Implement GtkAccessible

Override the get_platform_state vfunc to get
the focused state from the GtkText widget within.

text: Ignore text widgets for a11y

We want to implement the Text interface on the
wrapper entries.

atspi: Use gtk_accessible_get_platform_state

accessible: Add gtk_accessible_get_platform_state

As a companion to go with the platform_change api,
add a gtk_accessible_get_platform_state() function
that can be used by backends to get the platform
state.

This is in preparation for making entries inherit
their focus states from the text widget within.

atspi: Use gtk_accessible_should_present

Replace explicit visibility check by this
more general method of determining whether
an accessible should be presented to the
a11y layer.

accessible: Add a way to hide accessibles

Similar to gtk_widget_should_layout(), add a
gtk_accessible_should_present() function that backends can
use to determine whether an accessible should be presented
or not.

Ways to make a widget not presented in a11y:
- hide the widget
- set its role to NONE
- make it have a NULL AT context

We will use this in future to hide the GtkText inside
an entry, since the Text implementation will be done
by the wrapper.

Cosmetics

atspi: Treat all entries the same for collecting state

We are determining editable state based on the
accessible role (although we could make it platform
state now), so cover all the roles that we use for
entry wrappers.

atspi: Fix collecting states

This is somewhat embarrassing.

Fix the build

atspi: D-Bus methods return tuples

I've learned this the hard way: When returning a
value from a D-Bus call, the variant construct must
*always* be g_variant_new ("(...)"...

Don't unref a floating variant

It gets consumed somewhere along the way.

atspi: Unregister objects on the bus

When a widget is going away, we need to remove
the context from the bus, or else ATs might have
the idea to call methods on them, leading to badness.

atspi: Emit property changes for focus

With this orca, actually speaks \o/.  Sadly, it only
says 'gtk modelbutton widget' so far, but its a start.

atspi: Cosmetics

Use simple wrappers instead of opencoding bit twiddling
all over the place.

widget: Notify a11y of focus changes

This is using the new 'platform changes' mechanism
to tell the a11y backends when focus changes.

a11y: Pass on platform changes

Add an enum for 'platform changes' to the at context
change notification mechanism. This will let us pass
along things that ARIA considers 'platform state' such
as focus or editability. The difference between the
platform state and other ARIA states is that we don't
keep the platform state separately in the at context
- backends are expected to just query the widgets.

This is just about avoiding notify listeners for
change notification.

atspi: Be more careful about indexes

Don't return a number for IndexInParent when we
don't have one.

atspi: Set some more atspi states

Pass on more of the states that are represented
as properties in aria: modal, multi-line, orientation.

Pass orientation property to accessible

We should set the accessible properties we have,
where they make sense. So set orientation, if the
widget is orientable.

wip: Emit StateChanged signals

This is not fully baked, but it is enough to make accerciser
notice when a text entry goes from editable to not editable.

atspi: Derive readonly state from aria properties

We can use the read-only property, together with the
accessible role, to determine whether to set editable
and read-only states for at-spi. This lets us avoid
directly poking at the widgets.

text: Set the readonly accessible property

This mirrors what we already do for GtkTextView.

atspi: Set editable state

ATs look at not just the implemented interfaces, but
also the states to decide what to do. It turns out that
the EditableText interface is only used by accerciser
if the editable state is set. So set it.

atspi: Implement EditableText interface

Implement EditableText for GtkText and GtkTextView.

atspi: Break out the Value implementation

This isn't necessarily very big, but it keeps
the widget checks out of gtkatspicontext.c, and
it is a nice pattern.

atspi: Break out the Text implementations

Move the implementation of the Text interface
to its own source file, and split it up along
widget lines, to avoid it becoming too messy.

scalebutton: Set accessible value properties

This is what we did in GTK 3.

paned: Set accessible value properties

This is what we did in GTK 3.

Simplify GetInterfaces handling

It is error prone to keep the same conditions in sync
in two places. Instead, just assemble the list of interfaces
as we register objects, and use when GetInterfaces is called.

atspi: Implement Value for more widgets

Apply the Value implementation to the widgets where
we had one in GTK 3: GtkLevelBar, GtkRange, GtkScaleButton,
GtkSpinButton, GtkPaned, GtkProgressBar. To make these
work, the widgets need to set the accessible value properties.

atspi: Implement Value interface for ranges

atspi: Implement Text interface for text views

With this, all relevant widgets support the
Text interface.

atspi: Add textview utilities

These are very similar to the pango utilities,
and are copying code from the textview accessible
implementation in GTK 3.

atspi: Export more pango utils

We are going to reuse some of the code that does
the pango -> atspi attribute conversion for text
tags.

atspi: Implement text for GtkText widgets too

There is some open question here whether the interface
should be implemented on the outer or the inner widget
of the entry-text pairs. For now, our hand is forced,
since only GtkText provides access to the layout that
we need for implementing many of the interface methods.

atspi: Implement Text interface for labels

This is a not-quite-complete implementation of the
Text interface for GtkLabel. The missing parts are
anything around extents and positions, as well as
the ScrollSubstring apis.

atspi: Add pango utilities

This code is more or less a direct copy of what
we had in gtkpango.c in 3.x.

atspicontext: Fix GetIndexInParent for toplevels

For toplevels, we need to return the index in the
list of toplevels, since that is what GtkAtspiRoot
is using.

atcontext: labelled-by has a reference list

This is unclear - our docs state that all the
relations have value type reference, but in fact
they all have value type reference list.

atspicontext: Implement GetRelationSet

This translates relations as far as the match.

I'm not sure yet what we can do about the fact that
atspi expects relations to be bidirectional (ie have
label-for *and* labelled-by) while aria has only one
direction.

atspiroot: Stub out GetRelationSet

This needs to be fully implemented, for now sending
an empty relation set back prevents accerciser from
getting hung up.

atspi: Add the AtspiRelationType enum

This is what we need to map the aria relation
types to.

Move atspi enums to gtkatspiprivate.h

Add a GetInterfaces method

It turns out that accerciser depends on this undocumented
method that is not in the xml at all, otherwise interface
sections in the accerciser ui never get enabled.

Don't pass NULL to g_variant_new_string

That does not work.

atspi utils: Fix an oversight

gtk_accessible_role_to_atspi_role must always return
an atspi role. The fallback was returning an aria
role.

Fixup: Add a forgotten #pragma once

a11y: Convenience API for referencing ATSPI root node

We turn the root node into a reference fairly often, so it's worth it to
have a utility function that does this for us.

a11y: Add utility function for null refs

ATSPI was written for CORBA, which allows passing around "nil"
as valid object references.

atspicontext: Implement GetState

Translate the aria states to at-spi's interpretation
of atk states.

atspiroot: Fix GetState implementation

When the GetState signature says 'au', it actually
means a bitset that is sent as a pair of 32bit integers.

atspiroot: Implement GetIndexInParent

Just for good measure

atspicontext: Implement GetIndexInParent

This is needed for ATs to take our tree seriously.

atspicontext: Implement more accessible api

Implement GetChildAtIndex, GetChildren and ChildCount.

atspiroot: Implement GetChildren

No surprises here.

atspiroot: Don't leak references

The reffing getter trap, lurking behind g_list_model_get_item().

atspiroot: Implement GetLocale

atspicontext: Print out the a11y bus address

Make our debug spew useful: Having the bus address
makes it easy to jump on the a11y bus to look around
with dbus tools.

a11y: Localise the role name of the root node

a11y: Register the Accessible interface on all AtSpiContext instances

This is not a complement implementation.